import { defineStore } from 'pinia';

export const useStore = defineStore('main', {
  state: () => {
    // 从localStorage加载会话信息
    let savedSessions = JSON.parse(localStorage.getItem('sessions') || '["default_session"]');
    const sessionInfo = JSON.parse(localStorage.getItem('sessionInfo') || '{}');
    
    // 确保至少有一个会话（默认会话）
    if (!savedSessions || savedSessions.length === 0) {
      savedSessions = ['default_session'];
      localStorage.setItem('sessions', JSON.stringify(savedSessions));
    }
    
    // 确保默认会话信息存在
    if (!sessionInfo['default_session']) {
      sessionInfo['default_session'] = {
        title: '默认会话',
        summary: '',
        lastMessage: '',
        createdAt: new Date().toISOString()
      };
      localStorage.setItem('sessionInfo', JSON.stringify(sessionInfo));
    }
    
    return {
      apiKey: localStorage.getItem('apiKey') || null,
      currentSession: localStorage.getItem('currentSession') || 'default_session',
      sessions: savedSessions,
      sessionInfo: sessionInfo, // 存储会话的标题和摘要
      messages: {},
      loading: false,
      error: null,
      useWorkflow: localStorage.getItem('useWorkflow') === 'true' || false,
      sidebarWidth: parseInt(localStorage.getItem('sidebarWidth') || '320') // 侧边栏宽度
    }
  },
  
  actions: {
    // 保存API Key
    setApiKey(key) {
      this.apiKey = key;
      localStorage.setItem('apiKey', key);
    },
    
    // 清除API Key（退出登录）
    clearApiKey() {
      this.apiKey = null;
      localStorage.removeItem('apiKey');
    },
    
    // 添加新会话（自动生成名称）
    addSession(sessionId = null) {
      // 如果未提供sessionId，自动生成一个
      if (!sessionId) {
        const timestamp = new Date().getTime();
        sessionId = `session_${timestamp}`;
      }
      
      if (!this.sessions.includes(sessionId)) {
        this.sessions.push(sessionId);
        localStorage.setItem('sessions', JSON.stringify(this.sessions));
        
        // 初始化会话信息
        if (!this.sessionInfo[sessionId]) {
          this.sessionInfo[sessionId] = {
            title: '新会话',
            summary: '',
            lastMessage: '',
            createdAt: new Date().toISOString()
          };
          this.saveSessionInfo();
        }
      }
      this.setCurrentSession(sessionId);
    },
    
    // 更新会话信息
    updateSessionInfo(sessionId, info) {
      if (!this.sessionInfo[sessionId]) {
        this.sessionInfo[sessionId] = {};
      }
      this.sessionInfo[sessionId] = {
        ...this.sessionInfo[sessionId],
        ...info,
        updatedAt: new Date().toISOString()
      };
      this.saveSessionInfo();
    },
    
    // 保存会话信息到localStorage
    saveSessionInfo() {
      localStorage.setItem('sessionInfo', JSON.stringify(this.sessionInfo));
    },
    
    // 从消息自动生成会话标题
    generateSessionTitle(sessionId, firstMessage) {
      if (!firstMessage || firstMessage.trim().length === 0) {
        return '新会话';
      }
      
      // 提取纯文本（移除markdown标记）
      let title = firstMessage;
      // 移除markdown标题标记
      title = title.replace(/^#{1,6}\s+/gm, '');
      // 移除代码块标记
      title = title.replace(/```[\s\S]*?```/g, '');
      // 移除行内代码标记
      title = title.replace(/`[^`]+`/g, '');
      // 移除链接标记
      title = title.replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1');
      // 移除其他markdown标记（粗体、斜体等）
      title = title.replace(/[*_~]{1,2}([^*_~]+)[*_~]{1,2}/g, '$1');
      // 移除换行和多余空格
      title = title.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
      
      // 取前30个字符作为标题
      if (title.length > 30) {
        title = title.substring(0, 30) + '...';
      }
      
      this.updateSessionInfo(sessionId, { title });
      return title;
    },
    
    // 更新会话的预览消息
    updateLastMessage(sessionId, message, isUser) {
      // 只保存第一个用户问题作为预览，不保存AI回复
      if (isUser && message) {
        // 提取纯文本（移除markdown标记）
        let preview = message;
        // 移除markdown标题标记
        preview = preview.replace(/^#{1,6}\s+/gm, '');
        // 移除代码块标记
        preview = preview.replace(/```[\s\S]*?```/g, '');
        // 移除行内代码标记
        preview = preview.replace(/`[^`]+`/g, '');
        // 移除链接标记
        preview = preview.replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1');
        // 移除其他markdown标记
        preview = preview.replace(/[*_~]{1,2}([^*_~]+)[*_~]{1,2}/g, '$1');
        // 移除换行和多余空格
        preview = preview.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
        // 限制长度
        if (preview.length > 50) {
          preview = preview.substring(0, 50) + '...';
        }
        this.updateSessionInfo(sessionId, { lastMessage: preview });
      }
    },
    
    // 设置当前会话
    setCurrentSession(sessionId) {
      this.currentSession = sessionId;
      localStorage.setItem('currentSession', sessionId);
    },
    
    // 删除会话
    removeSession(sessionId) {
      this.sessions = this.sessions.filter(id => id !== sessionId);
      
      // 如果删除后没有会话了，自动创建默认会话
      if (this.sessions.length === 0) {
        this.sessions.push('default_session');
        // 初始化默认会话信息
        if (!this.sessionInfo['default_session']) {
          this.sessionInfo['default_session'] = {
            title: '默认会话',
            summary: '',
            lastMessage: '',
            createdAt: new Date().toISOString()
          };
          this.saveSessionInfo();
        }
      }
      
      localStorage.setItem('sessions', JSON.stringify(this.sessions));
      
      // 如果删除的是当前会话，切换到默认会话或第一个会话
      if (sessionId === this.currentSession) {
        const newSession = this.sessions[0] || 'default_session';
        this.setCurrentSession(newSession);
        // 确保新会话在列表中
        if (!this.sessions.includes(newSession)) {
          this.sessions.push(newSession);
          localStorage.setItem('sessions', JSON.stringify(this.sessions));
        }
      }
    },
    
    // 保存消息到状态
    addMessage(sessionId, isUser, content, metadata = null) {
      if (!this.messages[sessionId]) {
        this.messages[sessionId] = [];
      }
      
      // 如果是第一条用户消息，立即更新会话标题
      const isFirstUserMessage = isUser && 
        this.messages[sessionId].length === 0;
      
      this.messages[sessionId].push({
        id: Date.now(),
        isUser,
        content,
        timestamp: new Date(),
        metadata: metadata || null
      });
      
      // 如果是第一条用户消息，立即生成标题
      if (isFirstUserMessage) {
        this.generateSessionTitle(sessionId, content);
      }
      
      // 只更新用户消息作为预览（第一个问题）
      if (isUser) {
        this.updateLastMessage(sessionId, content, isUser);
      }
    },
    
    // 更新消息内容
    updateMessage(sessionId, messageId, newContent) {
      const messages = this.messages[sessionId];
      if (!messages) return false;
      
      const index = messages.findIndex(msg => msg.id === messageId);
      if (index !== -1) {
        messages[index].content = newContent;
        messages[index].timestamp = new Date();
        // 如果是用户消息，更新预览
        if (messages[index].isUser) {
          this.updateLastMessage(sessionId, newContent, true);
        }
        return true;
      }
      return false;
    },
    
    // 删除指定消息及其后的所有消息
    removeMessagesAfter(sessionId, messageId) {
      const messages = this.messages[sessionId];
      if (!messages) return;
      
      const index = messages.findIndex(msg => msg.id === messageId);
      if (index !== -1) {
        // 删除该消息后的所有消息（保留该消息）
        this.messages[sessionId] = messages.slice(0, index + 1);
      }
    },
    
    // 根据ID获取消息
    getMessageById(sessionId, messageId) {
      const messages = this.messages[sessionId];
      if (!messages) return null;
      return messages.find(msg => msg.id === messageId);
    },
    
    // 设置侧边栏宽度（优化：避免频繁写入localStorage）
    setSidebarWidth(width, saveToStorage = true) {
      this.sidebarWidth = Math.max(200, Math.min(600, width)); // 限制在200-600px
      // 只在需要时保存到localStorage（如拖拽结束时）
      if (saveToStorage) {
        localStorage.setItem('sidebarWidth', this.sidebarWidth.toString());
      }
    },
    
    // 设置工作流模式
    setUseWorkflow(useWorkflow) {
      this.useWorkflow = useWorkflow;
      localStorage.setItem('useWorkflow', useWorkflow.toString());
    },
    
    
    // 从历史记录加载消息
    loadHistory(sessionId, history) {
      // 先清空当前会话的消息
      if (!this.messages[sessionId]) {
        this.messages[sessionId] = [];
      } else {
        this.messages[sessionId] = [];
      }
      
      if (!history || history.trim().length === 0) {
        return;
      }
      
      // 解析历史记录
      const lines = history.split('\n');
      let currentMessage = null;
      
      lines.forEach((line, index) => {
        const trimmedLine = line.trim();
        
        if (trimmedLine.startsWith('用户：')) {
          // 如果有未保存的消息，先保存
          if (currentMessage) {
            this.messages[sessionId].push({
              id: Date.now() - (lines.length - index) * 1000,
              isUser: currentMessage.isUser,
              content: currentMessage.content,
              timestamp: new Date(Date.now() - (lines.length - index) * 1000)
            });
          }
          // 开始新的用户消息
          const content = trimmedLine.replace('用户：', '').trim();
          if (content) {
            currentMessage = {
              isUser: true,
              content: content
            };
          }
        } else if (trimmedLine.startsWith('回复：')) {
          // 如果有未保存的消息，先保存
          if (currentMessage) {
            this.messages[sessionId].push({
              id: Date.now() - (lines.length - index) * 1000,
              isUser: currentMessage.isUser,
              content: currentMessage.content,
              timestamp: new Date(Date.now() - (lines.length - index) * 1000)
            });
          }
          // 开始新的AI回复
          const content = trimmedLine.replace('回复：', '').trim();
          if (content) {
            currentMessage = {
              isUser: false,
              content: content
            };
          }
        } else if (currentMessage && trimmedLine) {
          // 多行消息的续行
          currentMessage.content += '\n' + trimmedLine;
        }
      });
      
      // 保存最后一条消息
      if (currentMessage) {
        this.messages[sessionId].push({
          id: Date.now(),
          isUser: currentMessage.isUser,
          content: currentMessage.content,
          timestamp: new Date()
        });
        
        // 如果是AI回复，更新最后一条消息预览
        if (!currentMessage.isUser) {
          this.updateLastMessage(sessionId, currentMessage.content, false);
        }
      }
    },
    
    // 清空会话消息
    clearSessionMessages(sessionId) {
      this.messages[sessionId] = [];
    },
    
    // 设置加载状态
    setLoading(state) {
      this.loading = state;
    },
    
    // 设置错误信息
    setError(message) {
      this.error = message;
      // 3秒后自动清除错误信息
      setTimeout(() => {
        this.error = null;
      }, 3000);
    }
  }
});
